// 结果处理与显示模块

// 格式化价格显示
function formatPrice(price) {
    return price ? '¥' + parseFloat(price).toFixed(2) : '¥0.00';
}

// 格式化百分比显示
function formatPercentage(value) {
    return value ? (parseFloat(value) * 100).toFixed(2) + '%' : '0.00%';
}

// 格式化成交量显示
function formatVolume(volume) {
    volume = parseFloat(volume);
    if (volume >= 100000000) {
        return (volume / 100000000).toFixed(2) + '亿';
    } else if (volume >= 10000) {
        return (volume / 10000).toFixed(2) + '万';
    }
    return volume.toFixed(0);
}

// HTML转义函数
function escapeHtml(text) {
    const div = document.createElement('div');
    div.textContent = text;
    return div.innerHTML;
}

/**
 * 更新单只股票分析结果显示
 * @param {Object} data 分析结果数据
 */
export function updateAnalysisResult(data) {
    // 提取纯股票代码显示
    const pureSymbol = data.symbol.split('.')[0];
    
    // 显示股票代码、名称和行业
    let titleText = `${pureSymbol} ${data.stock_name || ''}`;
    if (data.industry) {
        titleText += ' - ' + data.industry;
    }
    titleText += ' 分析结果';
    
    document.getElementById('resultSymbol').textContent = titleText;
    document.getElementById('resultTime').textContent = new Date().toLocaleString('zh-CN');
    
    // 显示结果来源信息
    const sourceText = data.from_cache ? 
        `[缓存] 生成时间: ${data.cached_at}` : 
        '[实时] 刚刚生成';
    document.getElementById('resultSource').textContent = sourceText;
    
    // 更新技术指标
    document.getElementById('resultPrice').textContent = formatPrice(data.indicators.latest_price);
    document.getElementById('resultRSI').textContent = data.indicators.rsi_14 ? data.indicators.rsi_14.toFixed(2) : 'N/A';
    document.getElementById('resultVolatility').textContent = data.indicators.volatility_20 ? formatPercentage(data.indicators.volatility_20) : 'N/A';
    
    // 更新成交量信息
    if (document.getElementById('resultVolume')) {
        document.getElementById('resultVolume').textContent = data.indicators.volume ? formatVolume(data.indicators.volume) : 'N/A';
    }
    if (document.getElementById('resultVolumeMA5')) {
        document.getElementById('resultVolumeMA5').textContent = data.indicators.volume_ma5 ? formatVolume(data.indicators.volume_ma5) : 'N/A';
    }
    if (document.getElementById('resultVolumeRatio')) {
        document.getElementById('resultVolumeRatio').textContent = data.indicators.volume_ratio ? data.indicators.volume_ratio.toFixed(2) : 'N/A';
    }

    // 更新买入信号
    updateSignalsList('buySignals', data.indicators.signals.buy_signals);

    // 更新卖出信号
    updateSignalsList('sellSignals', data.indicators.signals.sell_signals);

    // 处理分析报告内容
    const processedAnalysis = processAnalysisText(data.analysis);
    document.getElementById('resultAnalysis').innerHTML = processedAnalysis;
}

/**
 * 更新信号列表显示
 * @param {string} elementId 元素ID
 * @param {Array} signals 信号数组
 */
export function updateSignalsList(elementId, signals) {
    const signalsElement = document.getElementById(elementId);
    
    if (signals && signals.length > 0) {
        let html = '';
        for (let i = 0; i < signals.length; i++) {
            html += '<li>' + signals[i] + '</li>';
        }
        signalsElement.innerHTML = html;
    } else {
        signalsElement.innerHTML = '<li>无信号</li>';
    }
}

/**
 * 处理分析文本，以纯文本形式显示
 * @param {string} analysis 分析文本内容
 * @returns {string} 处理后的文本
 */
function processAnalysisText(analysis) {
    // 移除所有Markdown格式符号
    let processedAnalysis = analysis
        .replace(/^#{1,6}\s*/gm, '')  // 移除标题符号
        .replace(/^[*\-+]\s*/gm, '')  // 移除列表符号
        .replace(/^\d+\.\s*/gm, '')  // 移除数字列表
        .replace(/\*\*(.*?)\*\*/g, '$1')  // 移除加粗符号
        .replace(/\*(.*?)\*/g, '$1');  // 移除斜体符号
    
    // 只保留换行符转换
    processedAnalysis = processedAnalysis.replace(/\n/g, '<br>');
    
    // 添加简单的段落包装，使文本有更好的阅读体验
    processedAnalysis = '<div class="simple-text-display">' + processedAnalysis + '</div>';
    
    return processedAnalysis;
}

/**
 * 尝试将文本格式转换为HTML表格
 * 识别以分隔符分隔的数据行
 * @param {string} text 文本内容
 * @returns {string} 处理后的文本（含表格）
 */
function convertTextToTable(text) {
    // 检测常见的表格格式，比如使用空格、制表符或竖线分隔的值
    const lines = text.split('<br>');
    let tableStart = -1;
    let tableEnd = -1;
    let separatorLineIndex = -1;
    
    // 尝试检测表格结构
    for (let i = 0; i < lines.length; i++) {
        // 检查是否有横线分隔符行
        if (/^\s*[-=]+\s*$/.test(lines[i]) || /^\s*[-=]+\s*[|+]\s*[-=]+/.test(lines[i])) {
            separatorLineIndex = i;
            // 表格开始于分隔符前一行
            tableStart = i - 1;
            
            // 找到表格结束位置
            for (let j = i + 1; j < lines.length; j++) {
                // 如果遇到空行或其他格式的行，认为表格结束
                if (lines[j].trim() === '' || /^\s*[-=]+\s*$/.test(lines[j]) || 
                    /^#/.test(lines[j].trim()) || /^[*\-]/.test(lines[j].trim())) {
                    tableEnd = j - 1;
                    break;
                }
            }
            // 如果没有找到结束位置，表格结束于最后一行
            if (tableEnd === -1 && separatorLineIndex < lines.length - 1) {
                tableEnd = lines.length - 1;
            }
            break;
        }
        
        // 检测使用竖线分隔的表格
        if (lines[i].split('|').length > 2 && i + 1 < lines.length) {
            tableStart = i;
            
            // 找到表格结束位置
            for (let j = i + 1; j < lines.length; j++) {
                if (lines[j].split('|').length <= 2 || lines[j].trim() === '') {
                    tableEnd = j - 1;
                    break;
                }
            }
            if (tableEnd === -1) {
                tableEnd = lines.length - 1;
            }
            break;
        }
        
        // 检测使用多空格分隔的表格（如股票数据）
        if (lines[i].trim().match(/\s{2,}/g) && lines[i].trim().split(/\s{2,}/).length >= 3) {
            tableStart = i;
            
            // 找到表格结束位置
            for (let j = i + 1; j < lines.length; j++) {
                if (!lines[j].trim().match(/\s{2,}/g) || lines[j].trim().split(/\s{2,}/).length < 3 || lines[j].trim() === '') {
                    tableEnd = j - 1;
                    break;
                }
            }
            if (tableEnd === -1) {
                tableEnd = lines.length - 1;
            }
            break;
        }
    }
    
    // 如果找到了表格结构，进行转换
    if (tableStart >= 0 && tableEnd >= tableStart) {
        let tableHtml = '<div style="overflow-x: auto; margin: 16px 0;">' +
                        '<table style="width: 100%; border-collapse: collapse; border: 1px solid #e5e7eb; font-size: 0.95rem;">';
        
        // 处理表格行
        for (let i = tableStart; i <= tableEnd; i++) {
            // 跳过分隔符行
            if (separatorLineIndex === i) continue;
            
            const line = lines[i].trim();
            if (line === '') continue;
            
            let cells;
            
            // 判断分隔符类型
            if (line.includes('|')) {
                // 使用竖线分隔
                cells = line.split('|').map(cell => cell.trim()).filter(cell => cell !== '');
            } else {
                // 使用多空格分隔
                cells = line.split(/\s{2,}/).map(cell => cell.trim());
            }
            
            // 第一行作为表头
            const isHeader = (i === tableStart);
            tableHtml += isHeader ? '<thead><tr style="background-color: #f3f4f6;">' : '<tbody><tr>';
            
            // 添加单元格
            for (let j = 0; j < cells.length; j++) {
                const cell = cells[j];
                const cellTag = isHeader ? 'th' : 'td';
                const cellStyle = isHeader ? 
                    'padding: 10px 12px; text-align: left; font-weight: bold; border: 1px solid #e5e7eb; color: #1f2937;' : 
                    'padding: 8px 12px; text-align: left; border: 1px solid #e5e7eb; vertical-align: top;';
                
                // 为数值单元格添加右对齐
                let cellAlign = '';
                if (!isHeader && /^[\d.,%\-]+$/.test(cell.replace(/^[￥$]/, ''))) {
                    cellAlign = 'text-align: right;';
                }
                
                tableHtml += `<${cellTag} style="${cellStyle} ${cellAlign}">${cell}</${cellTag}>`;
            }
            
            tableHtml += isHeader ? '</tr></thead>' : '</tr>';
        }
        
        tableHtml += '</tbody></table></div>';
        
        // 替换原始文本中的表格部分
        const beforeTable = lines.slice(0, tableStart).join('<br>');
        const afterTable = lines.slice(tableEnd + 1).join('<br>');
        
        return beforeTable + (beforeTable ? '<br>' : '') + tableHtml + (afterTable ? '<br>' + afterTable : '');
    }
    
    return text;
}

/**
 * 渲染批量分析结果
 * @param {Array} results 批量分析结果数组
 */
export function renderBatchResults(results) {
    const batchResults = document.getElementById('batchResults');
    batchResults.innerHTML = '';
    
    // 添加每个股票的分析卡片
    for (let i = 0; i < results.length; i++) {
        const data = results[i];
        
        if (data.error) {
            const card = document.createElement('div');
            card.className = 'bg-white rounded-lg shadow-md p-4 border border-danger/30';
            card.innerHTML = '<h3 class="text-lg font-bold text-danger">' + data.error + '</h3>';
            batchResults.appendChild(card);
            return;
        }

        const card = createResultCard(data);
        batchResults.appendChild(card);
    }

    // 添加查看详情事件监听
    addViewDetailsListeners();
}

/**
 * 创建单张结果卡片
 * @param {Object} data 股票数据
 * @returns {HTMLElement} 卡片元素
 */
function createResultCard(data) {
    // 确定信号强度和颜色
    let signalClass = 'text-neutral-500';
    let signalText = '持有';
    
    if (data.indicators.signals.buy_signals && data.indicators.signals.buy_signals.length > 0) {
        signalClass = 'text-success';
        signalText = '买入';
    } else if (data.indicators.signals.sell_signals && data.indicators.signals.sell_signals.length > 0) {
        signalClass = 'text-danger';
        signalText = '卖出';
    }

    const pureSymbol = data.symbol.split('.')[0];
    const stockName = data.stock_name || '';
    const industry = data.industry || '';
    const price = formatPrice(data.indicators.latest_price);
    const rsi = data.indicators.rsi_14 ? data.indicators.rsi_14.toFixed(2) : 'N/A';
    const volatility = data.indicators.volatility_20 ? formatPercentage(data.indicators.volatility_20) : 'N/A';
    const analysisPreview = data.analysis.substring(0, 100) + '...';
    
    const card = document.createElement('div');
    card.className = 'bg-white rounded-lg shadow-md p-5 hover:shadow-lg transition-shadow duration-300 card-shadow';
    
    card.innerHTML = `
        <div class="flex justify-between items-start mb-3">
            <div>
                <h3 class="text-xl font-bold text-neutral-800">${pureSymbol}</h3>
                <p class="text-sm text-neutral-600">${stockName}</p>
                ${industry ? `<p class="text-xs text-neutral-500">行业: ${industry}</p>` : ''}
                <p class="text-xs text-neutral-500">${data.from_cache ? `[缓存] ${data.cached_at}` : '[实时] 刚刚生成'}</p>
            </div>
            <span class="${signalClass} font-bold">${signalText}</span>
        </div>
        <div class="text-2xl font-bold text-neutral-800 mb-3">${price}</div>
        <div class="grid grid-cols-2 gap-2 mb-4">
            <div class="text-sm text-neutral-600">RSI: ${rsi}</div>
            <div class="text-sm text-neutral-600">波动率: ${volatility}</div>
        </div>
        <div class="text-sm text-neutral-700 mb-4 line-clamp-2">${analysisPreview}</div>
        <button class="viewDetailsBtn bg-primary/10 text-primary px-3 py-1 rounded-md text-sm hover:bg-primary/20 transition duration-300" data-symbol="${data.symbol}">
            查看详情
        </button>
    `;
    
    return card;
}

/**
 * 添加查看详情按钮的事件监听器
 */
export function addViewDetailsListeners() {
    const buttons = document.querySelectorAll('.viewDetailsBtn');
    for (let i = 0; i < buttons.length; i++) {
        buttons[i].addEventListener('click', function() {
            const symbol = this.getAttribute('data-symbol');
            document.getElementById('stockSymbol').value = symbol;
            analyzeStock(symbol);
        });
    }
}

/**
 * 保存分析结果为JSON文件
 * @param {string} symbol 股票代码
 */
export async function saveAnalysisResult(symbol) {
    try {
        const response = await fetch('/api/stocks/' + symbol);
        const data = await response.json();
        
        // 创建下载链接
        const blob = new Blob([JSON.stringify(data, null, 2)], { type: 'application/json' });
        const url = URL.createObjectURL(blob);
        const a = document.createElement('a');
        a.href = url;
        
        // 生成文件名
        const dateStr = new Date().toISOString().split('T')[0];
        let fileName = symbol;
        
        if (data.stock_name) {
            // 移除文件名中可能不合法的字符
            const safeName = data.stock_name.replace(/[\\/:*?"<>|]/g, '_');
            fileName += '_' + safeName;
        }
        
        a.download = `${fileName}_analysis_${dateStr}.json`;
        
        // 触发下载
        document.body.appendChild(a);
        a.click();
        document.body.removeChild(a);
        URL.revokeObjectURL(url);
    } catch (error) {
        console.error('保存结果失败:', error);
        showError('保存结果时出错！');
    }
}

/**
 * 分享功能（模拟）
 */
export function shareAnalysisResult() {
    alert('分享功能：复制当前页面链接即可分享分析结果。');
}

/**
 * 显示分析结果
 * @param {Object} data 分析结果数据
 */
export function displayResult(data) {
    updateAnalysisResult(data);
    document.getElementById('resultContainer').classList.remove('hidden');
    document.getElementById('resultContainer').scrollIntoView({ behavior: 'smooth' });
}

/**
 * 显示批量分析结果
 * @param {Array} results 批量分析结果数组
 */
export function displayBatchResults(results) {
    renderBatchResults(results);
    document.getElementById('batchResultContainer').classList.remove('hidden');
    document.getElementById('batchResultContainer').scrollIntoView({ behavior: 'smooth' });
}

/**
 * 显示错误信息
 * @param {string} message 错误信息
 */
export function showError(message) {
    const errorContainer = document.getElementById('errorContainer');
    const errorMessage = document.getElementById('errorMessage');
    
    errorMessage.textContent = message;
    errorContainer.classList.remove('hidden');
    
    // 3秒后自动隐藏
    setTimeout(() => {
        errorContainer.classList.add('hidden');
    }, 3000);
}

/**
 * 显示进度条
 * @param {string} symbol 股票代码
 * @param {string} step 进度步骤描述
 */
export function showProgress(symbol, step) {
    const progressContainer = document.getElementById('progressContainer');
    const progressSymbol = document.getElementById('progressSymbol');
    const progressStep = document.getElementById('progressStep');
    
    progressSymbol.textContent = symbol;
    progressStep.textContent = step;
    progressContainer.classList.remove('hidden');
}

/**
 * 更新进度条
 * @param {number} percentage 进度百分比
 */
export function updateProgress(percentage) {
    const progressBar = document.getElementById('progressBar');
    const progressPercentage = document.getElementById('progressPercentage');
    
    progressBar.style.width = percentage + '%';
    progressPercentage.textContent = percentage + '%';
}